home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 October / CD CHIP.ISO / Vari / Multimed / 95ITERAT / _SETUP.1 / Fracsub1.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-24  |  26.4 KB  |  1,346 lines
  1. //////////////////////////////////////////////////////////////////
  2. // fracsub1.cpp
  3. // This file is an extension of CIterationsview
  4. // Class Function implementations
  5. //
  6. //
  7.  
  8. #include "stdafx.h"
  9. #include "itriazon.h"
  10. #include "itriadoc.h"
  11. #include "itriavw.h"
  12. #include "external.h"
  13. #include "math.h"
  14.  
  15. void CIterationsView::TestPattern5()
  16. {
  17.     // int j;
  18.  
  19.     py = Row;
  20.     
  21.     if (nMatrix)
  22.     {
  23.       for (px = 0; px < dim.cx ; px++)
  24.         {
  25.             if (!m_dib.SpatialOperator(px, py, NMAX))
  26.             {
  27.                 AfxMessageBox("Error with Spatial Operator");
  28.                 bDraw = FALSE;
  29.                 bLaunch = FALSE;
  30.             }
  31.         }
  32.         Row--;
  33.         return;
  34.     }
  35.  
  36.     for (px = 0; px < dim.cx ; px++)
  37.   {
  38.  
  39.         TestPatternSub();
  40.  
  41.   }
  42.  
  43.     Row--;
  44. }
  45.                 
  46.  
  47. void CIterationsView::TestPatternSub()
  48. {
  49.     //char cstr[81];
  50.     
  51.     b_MAX = b_GT4 = FALSE;
  52.         xsquared = ysquared = 0;
  53.  
  54.         if (bOrbits)
  55.         {                                                                                        
  56.             px = rb_center_x;
  57.             py = rb_center_y;
  58.         }
  59.                 
  60.         x = xO + px * ldx,      /* start julia on pixel */
  61.     y = yO + py * ldy;
  62.  
  63.     if (jul == 0)
  64.         {
  65.             // Start mandelbrot set on 0,0 
  66.             cx = x;
  67.             cy = y;                                        // and use pixel for c.
  68.             //cx = x, cy = y, x = 0L, y = 0L;   // and use pixel for c.
  69.         }
  70.         else if (jul_save == 0)                         // If previous was a mandelbrot
  71.         {
  72.             cx = CRMID; 
  73.             cy = CIMID;                      // A Julia coordinate            
  74.         }
  75.         if (bZeroInit && jul == 0)
  76.         {
  77.             x = 0; 
  78.             y = 0;
  79.         }
  80.                         
  81.         /////////////////////////////////////////////////////////////////////
  82.         //////////////////////////////////////////////////////////////////////        
  83.  
  84.         /* main iteration loop; go until the distance to the origin is
  85.          * greater than 2 (i.e. square of the distance > 4), or we hit
  86.          * the maximum number of iterations */
  87.     
  88.     xsquared = 0, ysquared = 0;
  89.  
  90.         // Chack minimum and maximum valid limits
  91.         //if (cx == 0)
  92.         //    cx = zerotol;
  93.         //if (cy == 0)
  94.         //    cy = zerotol;    
  95.  
  96.         if (cx < zerotol && cx > -zerotol)
  97.         {
  98.             if (cx >= 0)
  99.                 cx = zerotol;
  100.             else
  101.                 cx = -zerotol;
  102.         }
  103.  
  104.         if (cy < zerotol && cy > -zerotol)
  105.         {
  106.             if (cy >= 0)
  107.                 cy = zerotol;
  108.             else
  109.                 cy = -zerotol;
  110.         }
  111.         
  112.         if (x < zerotol && x > -zerotol)
  113.         {
  114.             if (x >= 0)
  115.                 x = zerotol;
  116.             else
  117.                 x = -zerotol;
  118.         }
  119.  
  120.         if (y < zerotol && y > -zerotol)
  121.         {
  122.             if (y >= 0)
  123.                 y = zerotol;
  124.             else
  125.                 y = -zerotol;
  126.         }
  127.         
  128.         // Initialize some complex variables
  129.         z = cmplx (x, y );
  130.         z.set_biomorph(dBiomorph);
  131.         c = cmplx(cx, cy);
  132.  
  133.         cNMAX = cmplx(0,0);
  134.         z2 = cmplx(0,0);
  135.  
  136.         if (jul == 0)
  137.         {
  138.             c *= cOrient;
  139.             if (bFilter_12) c=(c^dFilter_12Power).clog()/dFilter_12Magnif;
  140.             if (Inverted)    {    c = 1/c; z=1/z; }
  141.             if (Inverted_X)    c.set_real(1/c.real());
  142.             if (Inverted_Y)    c.set_imag(1/c.imag());
  143.         }
  144.         else if (jul_save == 0)
  145.         {
  146.             c *= cOrient;
  147.             z *= cOrient;
  148.             if (bFilter_12)
  149.             {
  150.                 c=(c^dFilter_12Power).clog()/dFilter_12Magnif;
  151.                 z=(z^dFilter_12Power).clog()/dFilter_12Magnif;
  152.             }
  153.             if (Inverted) { c = 1/c; z = 1/z; }
  154.             if (Inverted_X) { c.set_real(1/c.real()); z.set_real(1/z.real()); }
  155.             if (Inverted_Y) { c.set_imag(1/c.imag()); z.set_imag(1/z.imag()); }
  156.         }
  157.         else
  158.         {
  159.             z *= cOrient;
  160.             //c *= cOrient;  // ??????????????
  161.             if (bFilter_12) z=(z^dFilter_12Power).clog()/dFilter_12Magnif;
  162.             if (Inverted)    z = 1/z;
  163.             if (Inverted_X)    z.set_real(1/z.real());
  164.             if (Inverted_Y)    z.set_imag(1/z.imag());
  165.         }
  166.             
  167.         x =  z.real();
  168.         y =  z.imaginary();
  169.         cx = c.real();
  170.         cy = c.imaginary();
  171.         
  172.         if (nPreFractal && bCombo)
  173.         {
  174.             PreCombo();
  175.  
  176.         switch (nPreFractal)
  177.             {
  178.                 case 1:        
  179.                     z=1/z.csin();
  180.                     break;
  181.                     
  182.                 case 2:
  183.                     z=1/z.ccos();
  184.                     break;
  185.  
  186.                 case 3:
  187.                     z=1/z.clog();
  188.                     break;
  189.  
  190.                 case 4:        
  191.                     z=1/tangent(z);
  192.                     break;
  193.  
  194.                 case 5:        
  195.                     z=1/sinh(z);
  196.                     break;
  197.                 
  198.                 case 6:        
  199.                     z=1/asin(z);
  200.                     break;
  201.                 
  202.                 case 7:        
  203.                     z=1/acos(z);
  204.                     break;
  205.                 
  206.                 case 8:        
  207.                     z=1/arctan(z);
  208.                     break;
  209.  
  210.                 case 9:        
  211.                     z=1/(z*z);
  212.                     break;
  213.  
  214.                 case 10:
  215.                         z = z^.5;
  216.                     break;
  217.  
  218.                 case 11:
  219.                     z = 1/(c + z);
  220.                     break;
  221.                     
  222.                 case 12:
  223.                     z = 1/(c * z);
  224.                     break;
  225.                     
  226.                 case 13:
  227.                     z = c/z;
  228.                     break;
  229.                     
  230.                 case 14:
  231.                     z = z / dBailout;
  232.                     break;
  233.                     
  234.                 case 15:
  235.                     z = (z+c) / dBailout;
  236.                     break;
  237.                     
  238.                 case 16:
  239.                     z = (z*c) / dBailout;
  240.                     break;
  241.                     
  242.                 default:
  243.                     break;
  244.  
  245.         }
  246.  
  247.         if (bComboCZ)
  248.             c = z;   
  249.         //z = cmplx (x, y );
  250.  
  251. //        if (nDistortion >= 57 && nDistortion <= 69)
  252. //        {
  253. //            // Newton fractal type
  254. //            c = z;   
  255. //            z = cmplx (x, y );
  256. //        }
  257.     }    
  258.  
  259.     if (nDistortion >= 57 && nDistortion <= 69)
  260.     {
  261.         // Newton fractal type
  262. //            c = z;   
  263.         z = cmplx (x, y );
  264.     }
  265.  
  266.     TestEquations();
  267. }
  268.  
  269.  
  270. /////////////////////////
  271. void CIterationsView::TestEquations()
  272. {
  273.         i = jrw = i3 = 0;
  274.         rr = 0;
  275.         dzx_save = dzy_save = 0;
  276.         dzx_save_quick = dzy_save_quick = 0;
  277.  
  278.         limit = sqrt(cx*cx+cy*cy);
  279.         dStrands_HI = limit + dStrands;
  280.         dStrands_LO = limit - dStrands;
  281.  
  282.         //limit = sqrt(cx*cx+cy*cy);
  283.         //limit = cx*cx+cy*cy;
  284.  
  285.         JMAX = NMAX-1;
  286.  
  287.         switch (nDistortion)
  288.         {
  289.             case 0:     // Standard Fractal
  290.                 
  291.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  292.             {
  293.                     z = z*z+c;
  294.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  295.                 }
  296.                 if (nFilter) Filter_Complete();
  297.                 break;
  298.  
  299.             case 1:
  300.                 //z2 = cmplx(42,42);
  301.                 //while ((c-z2).abs() > 1E-4 && i++ < NMAX-3)
  302.                 //{
  303.                 //    z2 = c;        
  304.             //    //c = c - ((c^3)-1)/(3*(c^2));
  305.                 //    c = 
  306.                 //    if (nFilter) Delta_z(c.real(), c.imaginary());
  307.                 //}
  308.                 //if (nFilter) Filter_Complete();            
  309.  
  310.                 if (jul == 0)
  311.                     z = cmplx(0,0);
  312.  
  313.                 //c = z;   
  314.                 //z = cmplx (x, y );
  315.  
  316.                 if (jul == 1 && !bCombo)
  317.                 {
  318.                     c = cmplx(cx, cy);                
  319.                 }
  320.                                         
  321.                 //z +=1;
  322.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  323.             {
  324.                     z = z-((z*z*z)+(c-1)*z-c)/(3*(z*z)+c-1);                    
  325.                     
  326.                     //z = z - (z*z*z-1) / (3*z*z) + c;
  327.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  328.                 }
  329.                 if (nFilter) Filter_Complete();
  330.  
  331.  
  332.                 break;        
  333.                 
  334.             case 2: // 
  335.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  336.             {
  337.                     z = (z*z+c)/c + c;
  338.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  339.                 }
  340.                 if (nFilter) Filter_Complete();
  341.                 break;        
  342.  
  343.             case 3:  // Empty
  344.             for (i = 0; i <= JMAX && z.squares() < dBailout ; i++)
  345.             {
  346.                     z = 1/(z*z + 1/c) * z*z + c;
  347.                  if (nFilter) Delta_z(z.real(), z.imaginary());
  348.                 }
  349.                 if (nFilter) Filter_Complete();
  350.                 break;        
  351.  
  352.             case 4:  // 
  353.             for (i = 0; i <= JMAX && z.squares() < dBailout ; i++)
  354.             {
  355.                     z = z.ccos()*c;
  356.                     if (nFilter) Delta_z(z.real(), z.imag());
  357.                 }
  358.                 if (nFilter) Filter_Complete();
  359.                 break;
  360.  
  361.             case 5:  // Distortion (Double Bomber)
  362.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  363.             {
  364.                     z = ((z*z+c)/c).ccos() + c;
  365.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  366.                 }
  367.                 if (nFilter) Filter_Complete();
  368.                 break;        
  369.  
  370.             case 6:  // Testing
  371.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  372.                 {
  373.                     z = z*z+c*(1+z.squares());
  374.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  375.                 }
  376.                 if (nFilter) Filter_Complete();
  377.                 break;
  378.  
  379.             case 7:
  380.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  381.                 {
  382.                     z = ((z*z)/(1+z))+c;
  383.                  if (nFilter) Delta_z(z.real(), z.imaginary());
  384.                 }
  385.                 if (nFilter) Filter_Complete();
  386.                 break;
  387.                 
  388.             case 8:
  389.                 /////////////////////////////////////////////////////////
  390.                 // Roger T. Stevens Methods
  391.                 // Legendre Polynomial Fractal
  392.                                 
  393.                 //Pattern5_Case08();
  394.                 //z.set_real(x);
  395.                 //z.set_imag(y);
  396.                 //8.) F(z) = ((5z^3 - 3z) / 2) + c; [Legendre Polynomial]
  397.  
  398.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  399.                 {
  400.                     z = ((5*(z^3) - 3*z) / 2) + c;
  401.                  if (nFilter) Delta_z(z.real(), z.imaginary());
  402.                 }
  403.  
  404.                 if (nFilter) Filter_Complete();
  405.                 break;    
  406.  
  407.             case 9:
  408.                 /////////////////////////////////////////////////////////
  409.                 // Fractal 9
  410.                 if (jul == 0)
  411.                     z = cmplx(0,0);
  412.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  413.                 {
  414.                     z = z*z+c*(i/(int)rn);
  415.                  if (nFilter) Delta_z(z.real(), z.imaginary());
  416.                 }
  417.                 if (nFilter) Filter_Complete();
  418.                 break;
  419.  
  420.             case 10:
  421.                 /////////////////////////////////////////////////////////
  422.                 // Roger T. Stevens Methods
  423.                 // 3rd Order Newton
  424.                 Pattern5_Case10();
  425.                 z.set_real(x);
  426.                 z.set_imag(y);
  427.  
  428.                 break;
  429.  
  430.             case 11:
  431.                 /////////////////////////////////////////////////////////
  432.                 // Roger T. Stevens Methods
  433.                 // 7nth Order Newton
  434.                 Pattern5_Case11();
  435.                 z.set_real(x);
  436.                 z.set_imag(y);
  437.  
  438.                 break;
  439.           
  440.           case 12:
  441.                 // Generalized Mandelbrot
  442.                 cn = cmplx (rorder_r, rorder_i);
  443.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  444.                 {
  445.                     z = (z^cn)+c;
  446.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  447.                 }
  448.                 
  449.                 if (nFilter) Filter_Complete();
  450.                 break;    
  451.  
  452.           case 13:
  453.                 t=(c*c*c).csin();
  454.                 t2=(c*c).ccos();
  455.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  456.             {
  457.                     //z=(z*z).ccos()-(z*z*z).csin()-(z*z).ccos()+c;
  458.                     z=(z*z).ccos()-t-t2+c;
  459.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  460.                 }
  461.                 if (nFilter) Filter_Complete();
  462.                  break;    
  463.  
  464.           case 14:
  465.                 t=(c*c).ccos();
  466.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  467.             {
  468.                     z=(z*z).csin()-.2*z*z+c+t;
  469.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  470.                 }
  471.                 if (nFilter) Filter_Complete();
  472.                 break;    
  473.  
  474.           case 15:
  475.               // Roger T. Stevens method for the Tchebychev C5 fractal
  476. //                Pattern5_Case15();
  477. //                z.set_real(x);
  478. //                z.set_imag(y);
  479.  
  480.                 //15.) F(z) = c(z^5 - 5z^3 + 5z); [Tchebychev C5]
  481.  
  482.                 // z = c(z^5 - 5z^3 + 5z); [Tchebychev C5]
  483.  
  484.                 if (jul == 0)
  485.                     z = c;
  486.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  487.             {
  488.                     z = c*(z^5) - c*5*(z^3) + c*5*z; 
  489.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  490.                 }
  491.                 if (nFilter) Filter_Complete();
  492.                 break;    
  493.  
  494.           case 17:
  495.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  496.             {
  497.                     //z = ((z*z).csin() + c + c/dBailout);
  498.                     //z = ((z^7) + 1)^(1/3) + c;
  499.                     //z = c*z.ccos();
  500.                     z = z*z*sin(z.real()) + c*z*cos(z.imag()) + c;
  501.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  502.                 }
  503.                                 
  504.                 if (nFilter) Filter_Complete();
  505.                 break;    
  506.  
  507.           case 18:
  508.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  509.             {
  510.                     //z = ((z*z).cexp())/(z + c);
  511.                     z = ((z*z + c)^2) + z + c;
  512.                     if (nFilter) Delta_z(z.real(), z.imaginary());
  513.                 }
  514.                                 
  515.                 if (nFilter) Filter_Complete();
  516.                 break;
  517.                 
  518.             case 19:
  519.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  520.                 {
  521.                     z = ((z.ccos()*c).ccos()+c).ccos()*c;
  522.                  if (nFilter) Delta_z(z.real(), z.imaginary());
  523.                 }
  524.                 if (nFilter) Filter_Complete();
  525.                 break;        
  526.  
  527.             case 20:
  528.                 // Variation Real
  529.             for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  530.             {
  531.                     z = z*z+c;
  532.                     if (nFilter) Delta_z(z.real(), z.imag());
  533.                     z.set_real(z.real()*z.real());
  534.                 }
  535.                 if (nFilter) Filter_Complete();
  536.                 break;        
  537.  
  538.             case 21:
  539.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  540.                 {
  541.                     z=z*z+c;
  542.                 }
  543.                 z=1/z.ccos();
  544.                 for (i = 0; i < JMAX && z.squares() < dBailout ; i++)
  545.             {
  546.                     z=z*z+c;
  547.                     if (nFilter) Delta_z(z.real(), z.imag());
  548.                 }
  549.                 if (nFilter) Filter_Complete();
  550.                 break;        
  551.  
  552.             case 16:
  553.             case 22:     // Real World Fractal Equations
  554.             case 23:
  555.             case 24:
  556.             case 25:
  557.             case 26:
  558.             case 27:
  559.             case 28:
  560.             case 29:
  561.             case 30:
  562.             case 31:
  563.             case 32:
  564.             case 33:
  565.             case 34:
  566.             case 35:
  567.             case 36:
  568.             case 37:
  569.             case 38:
  570.             case 39:
  571.             case 40:
  572.             case 41:
  573.             case 42:
  574.             case 43:
  575.             case 44:
  576.             case 45:
  577.             case 46:
  578.             case 47:
  579.             case 48:
  580.             case 49:
  581.             case 50:
  582.             case 51:
  583.             case 52:
  584.             case 53:
  585.             case 54:
  586.             case 55:
  587.             case 56:
  588.             case 57:
  589.             case 58:
  590.             case 59:
  591.             case 60:
  592.             case 61:
  593.             case 62:
  594.             case 63:
  595.             case 64:
  596.             case 65:
  597.             case 66:
  598.             case 67:
  599.             case 68:
  600.             case 69:
  601.             case 70:
  602.             case 71:
  603.             case 72:
  604.             case 73:
  605.             case 74:
  606.             case 75:
  607.             case 76:
  608.             case 77:
  609.             case 78:
  610.             case 79:
  611.             case 80:
  612.             case 81:
  613.             case 82:
  614.             case 83:
  615.             case 84:
  616.             case 85:
  617.             case 90:
  618.             case 91:
  619.             case 92:
  620.             case 93:
  621.             case 94:
  622.             case 95:
  623.             case 96:
  624.             case 97:
  625.             case 98:
  626.             case 99:
  627.             case 100:
  628.  
  629.                 RealWorld();
  630.  
  631.                 break;
  632.  
  633.             case 101:
  634.             case 102:
  635.             case 103:
  636.             case 104:
  637.             case 105:
  638.             case 106:
  639.             case 107:
  640.             case 108:
  641.             case 109:
  642.             case 110:
  643.             case 111:
  644.             case 112:
  645.             case 113:
  646.             case 114:
  647.             case 115:
  648.             case 116:
  649.             case 117:
  650.             case 118:
  651.             case 119:
  652.             case 120:
  653.             case 121:
  654.             case 122:
  655.             case 123:
  656.             case 124:
  657.             case 125:
  658.             case 126:
  659.             case 127:
  660.             case 128:
  661.             case 129:
  662.             case 130:
  663.             case 131:
  664.             case 132:
  665.             case 133:
  666.             case 134:
  667.             case 135:
  668.             case 136:
  669.             case 137:
  670.             case 138:
  671.             case 139:
  672.             case 140:
  673.             case 141:
  674.             case 142:
  675.             case 143:
  676.             case 144:
  677.             case 145:
  678.             case 146:
  679.             case 147:
  680.             case 148:
  681.             case 149:
  682.             case 150:
  683.             case 151:
  684.             case 152:
  685.             case 153:
  686.             case 154:
  687.             case 155:
  688.             case 156:
  689.             case 157:
  690.             case 158:
  691.             case 159:
  692.             case 160:
  693.             case 161:
  694.             case 162:
  695.             case 163:
  696.             case 164:
  697.             case 165:
  698.             case 166:
  699.             case 167:
  700.  
  701.                 Genesis();
  702.  
  703.                 break;
  704.  
  705.             default:
  706.               AfxMessageBox("This equation number does not exist");
  707.                 Row = RowMax;
  708.                 Col = ColMax;
  709.                 px = dim.cx;
  710.                 py = dim.cy;
  711.                 bAbort = TRUE;
  712.                 bPostFractal = FALSE;
  713.                 
  714.                 break;
  715.  
  716.         }    
  717.  
  718.         if (!b_MAX)
  719.         {
  720.             if (i >= JMAX)
  721.                 b_MAX = TRUE;
  722.         }
  723.  
  724.         // Get the maximum iteration
  725.         if (i > temp_max)
  726.             temp_max = i;
  727.  
  728.         //x = z.real();
  729.         //y = z.imag();
  730.         
  731.         xsquared = z.real() * z.real();
  732.         ysquared = z.imaginary() * z.imaginary();
  733.  
  734.         if (b_MAX && (nIGOption || nGradientTest))  // Enhance the inside bay (Inside Gradients)
  735.         {
  736.             //if (!xsquared + ysquared <  zerotol &&        // 4
  737.                  //    xsquared + ysquared > -zerotol)         // Check for a valid range
  738.             if (xsquared < zerotol && xsquared > -zerotol)
  739.                 xsquared = zerotol;
  740.             if (ysquared < zerotol && ysquared > -zerotol)
  741.                 ysquared = zerotol;
  742.  
  743.             {
  744.                 switch (nIGOption)
  745.                 {
  746.                     case 0:
  747.                         
  748.                         xsquared *=100;
  749.                         ysquared *=100;
  750.                         
  751.                         break;
  752.                 
  753.             case 1:
  754.  
  755.                         if (xsquared != 0) 
  756.                             xsquared = (CRMAX - CRMIN ) * (fabsl(sinl(xsquared)*10));
  757.                         if (ysquared != 0)
  758.                             ysquared = (CIMAX - CIMIN ) * (fabsl(cosl(ysquared)*10)); 
  759.  
  760.            break;
  761.                         
  762.                     case 2:
  763.                         if (xsquared != 0) 
  764.                             xsquared = (1 / (CRMAX - CRMIN )) * 10 * xsquared ;
  765.                         if (ysquared != 0)
  766.                             ysquared = (1 / (CIMAX - CIMIN )) * 10 * ysquared ;
  767.               break;
  768.  
  769.             case 3:
  770.                         if (xsquared != 0) 
  771.                             xsquared = (( 1.0) - (-2.0) ) * (sinl(xsquared)*10);
  772.                         if (ysquared != 0)
  773.                             ysquared = (( 1.2) - (-1.2) ) * (log10l(ysquared)*10); 
  774.             break;
  775.                         
  776.                     case 4:
  777.                         if (xsquared != 0) 
  778.                             xsquared = (( 1.0) - (-2.0) ) * 10 * fabsl(sinl(xsquared)) ;
  779.                         if (ysquared != 0)
  780.                             ysquared = (( 1.2) - (-1.2) ) * 10 * fabsl(sinl(ysquared)) ;
  781.               break;
  782.  
  783.                     
  784.                     default:
  785.                         AfxMessageBox("Shouldn't get here IGOptions");
  786.                         break;
  787.                 }        
  788.  
  789.                 switch (nGradientTest)
  790.                 {
  791.                     case 0:
  792.                         // standard fractal
  793.                         break;     // do nothing
  794.  
  795.                     case 1:
  796.                         // bay addition                
  797.                         da = (xsquared+ysquared)*nBay100;  //
  798.                         i = (int) da + i;
  799.                         i %= NMAX;
  800.  
  801.                     break;
  802.  
  803.                 case 2:    
  804.                     // b_bay_multiply)
  805.                         dm = xsquared*ysquared*nBay1000; // 1000
  806.                         i = (int) dm + i;
  807.                         i %= NMAX;
  808.  
  809.                     break;
  810.  
  811.                 case 3:    
  812.                         // bay addition                
  813.                         dm = xsquared*ysquared*nBay1000;  // 1000
  814.                         da =    (xsquared+ysquared)*nBay100;  // 100
  815.                         i = (int) (dm+da) + i;
  816.                         i %= NMAX;
  817.  
  818.                     break;
  819.                 
  820.                     case 4:        
  821.                         // bay multiplication                
  822.                         dm = xsquared*ysquared*nBay1000;
  823.                         da = (xsquared+ysquared)*nBay100;
  824.                         i = (int) (dm*da) + i;
  825.                         i %= NMAX;
  826.  
  827.                         break;
  828.                     
  829.                 case 5:
  830.                         // bay subtraction
  831.                         dm = xsquared*ysquared*nBay1000;
  832.                         da = (xsquared+ysquared)*nBay100;
  833.                         i = (int) ((da-dm) + (double)i);
  834.                         i %= NMAX;
  835.  
  836.               break;
  837.           
  838.                 case 6:
  839.                         // bay division
  840.                         dm = xsquared*ysquared*nBay1000;
  841.                         da = (xsquared+ysquared)*nBay100;
  842.                         if (dm < zerotol)
  843.                             dm = zerotol;
  844.                         i = (int) (da/dm) + i;
  845.                         i %= NMAX;
  846.               
  847.               break;
  848.  
  849.                 case 7:
  850.                         dm = xsquared*ysquared;
  851.                         da = (xsquared+ysquared);
  852.                         i = (int) (sqrtl(dm*dm*da*da)*nBay100) + i;
  853.                         i %= NMAX;
  854.               break;
  855.  
  856.                 case 8:
  857.                         dm = xsquared*ysquared;
  858.                         da = (xsquared+ysquared);
  859.                         i = (int) (sqrtl(dm*da)*nBay100) + i;
  860.                         i %= NMAX;
  861.               break;
  862.  
  863.                 case 9:
  864.                         dm = xsquared*ysquared*nBay100;
  865.                         da = (xsquared+ysquared*nBay100);
  866.                         i = (int) fabsl(10*sinl(dm)*nBay1000+10*cosl(da)*nBay1000) + i;
  867.                         i %= NMAX;
  868.               break;
  869.  
  870.                 case 10:
  871.                         dm = xsquared*ysquared*nBay100;
  872.                         da = (xsquared+ysquared*nBay100);
  873.                         i = (int) fabsl((10*sinl(dm)*sinl(da))) + i;
  874.                         i %= NMAX;
  875.               break;
  876.  
  877.                 case 11:
  878.                         dm = xsquared*ysquared*nBay100;  // 500
  879.                         da = (xsquared+ysquared)*nBay100;
  880.                         i = (int) fabsl((10*sinl(dm)*logl(da))) + i;
  881.                         i %= NMAX;
  882.               break;
  883.  
  884.                 case 12:
  885.                         dm = xsquared*ysquared;
  886.                         da = (xsquared+ysquared)*nBay100;
  887.                         i = (int) (sqrtl(dm*da*da) * nBay1000) + i;
  888.                         i %= NMAX;
  889.               break;
  890.  
  891.                 case 13:
  892.                         da = (xsquared+ysquared)*nBay100;
  893.                         i = (int) (da*da) + i;
  894.                         i %= NMAX;
  895.               break;
  896.  
  897.                 case 14:
  898.                         dm = xsquared*ysquared*nBay1000;
  899.                         da = (xsquared+ysquared)*nBay100;
  900.                         if (dm > zerotol) 
  901.                             i = (int) ((da*da)/(dm)) + i;
  902.                         i %= NMAX;
  903.               break;
  904.  
  905.                 case 15:
  906.                         dm = xsquared*ysquared;
  907.                         da = (xsquared+ysquared)*nBay100;
  908.                         i = (int) (10*sinl(dm*da)* nBay1000) + i;
  909.                         i %= NMAX;
  910.               break;
  911.  
  912.                 case 16:
  913.                         da = (10*fabsl(sinl(xsquared))*fabsl(sinl(ysquared)))*nBay100;
  914.                         i = (int) (da*da) + i;
  915.                         i %= NMAX;
  916.               break;
  917.  
  918.                 case 17:
  919.                         da = (xsquared+ysquared);
  920.                         i = (int) (da*da*nBay100*2) + i;
  921.                         i %= NMAX;
  922.               break;
  923.  
  924.                 case 18:
  925.                         da = (xsquared+ysquared);
  926.                         i = (int) (da * da * nBay100 * .3) + i;
  927.                         i %= NMAX;
  928.               break;
  929.  
  930.                 case 19:
  931.                         da = (xsquared+ysquared);
  932.                         i = (int) (da * da * nBay100 * .05) + i;
  933.                         i %= NMAX;
  934.               break;
  935.  
  936.                     default:
  937.                         AfxMessageBox("fracsub, shouldn't get here");
  938.                         bDraw = FALSE;
  939.                         bLaunch = FALSE;
  940.                         break;
  941.             }
  942.         }    
  943.             b_MAX = FALSE;
  944.         }
  945.  
  946.         // Apply the Outside Bay Gradients
  947.         //if (xsquared + ysquared <  zerotol &&
  948.         //         xsquared + ysquared > -zerotol)         // Check for a valid range
  949.         {
  950.             switch(nOutsideTest)
  951.             {
  952.                 case 0:  // Standard fractal, do nothing
  953.                     break;
  954.                 
  955.                 case 1:
  956.                     i = (i + ((int) ((xsquared + ysquared) * nBay1000))) % NMAX;
  957.               break;
  958.           
  959.               case 2:
  960.                     i = (i + ((int) (((xsquared+1) / (ysquared+1)) * nBay1000))) % NMAX;
  961.                     break;
  962.  
  963.                 case 3:
  964.                     i = (i + (int) (xsquared * ysquared * nBay1000)) % NMAX;
  965.             break;
  966.  
  967.                 case 4:
  968.                     i = (i + ((int) (fabsl(xsquared - ysquared) * nBay1000))) % NMAX;
  969.               break;
  970.  
  971.                 case 5:
  972.                     i = (i + ((int) (sqrtl(xsquared * ysquared) * nBay1000))) % NMAX;
  973.                     break;
  974.                 
  975.                 case 6:
  976.                     i = (i + ((int) ((x + y) * nBay1000))) % NMAX;
  977.                     break;
  978.  
  979.                 case 7:
  980.                     i = (i + ((int) (ysquared * nBay1000))) % NMAX;
  981.                     break;
  982.  
  983.                 case 8:
  984.                     i = (i + ((int) (x * y * nBay1000))) % NMAX;
  985.                     break;
  986.                 
  987.                 case 9:
  988.                     i = (i + ((int) ((nBay100*sinl(xsquared)+nBay100*sinl(ysquared)) * nBay1000))) % NMAX;
  989.                     break;
  990.  
  991.                 case 10:
  992.                     i = (i + ((int) ((1 + sinl(xsquared) * sinl(ysquared) * nBay1000)))) % NMAX;
  993.                     break;
  994.  
  995.                 case 11:
  996.                     i = (i + ((int) ((2*log10l(xsquared) + sinl(ysquared)) * nBay1000))) % NMAX;
  997.                     break;
  998.  
  999.                 case 12:
  1000.                     i = (i + ((int) ((sinl(xsquared) / (sinl(ysquared)+zerotol) * nBay1000)))) % NMAX;
  1001.                     break;
  1002.  
  1003.                 case 13:
  1004.                     i = (i + ((int) ((1+sinl(xsquared*ysquared) / (sinl(xsquared+ysquared)+zerotol) * nBay1000)))) % NMAX;
  1005.                     break;
  1006.  
  1007.                 case 14:
  1008.                     i = (i + ((int) (1+nBay1000*sinl(xsquared)+1+nBay1000*sinl(ysquared)))) % NMAX;
  1009.                     break;
  1010.  
  1011.                 default:
  1012.                     AfxMessageBox("Shouldn't get here, fracsub1");
  1013.                     break;
  1014.             
  1015.             }
  1016.         }    
  1017.  
  1018.         if (b_MAX && b_MAX_Zero)
  1019.             i = 0;
  1020.  
  1021.         i = abs(i);
  1022.         i %= NMAX;
  1023.         if (i == 0) i = 1;
  1024.  
  1025.         i = i / nLevel;
  1026.         i = i * nLevel;
  1027.  
  1028.         if (bPostProcess) PostProcess();
  1029.         
  1030.         if (bPostFractal)
  1031.             return;
  1032.  
  1033.         if (i < 0 || i > NMAX)
  1034.         {
  1035.             char cstr[81];
  1036.             wsprintf(cstr, "i=%d: Error", i);
  1037.             GetParent()->SetWindowText(cstr);
  1038.             i = 0;
  1039.         }    
  1040.  
  1041.     // Ok, Here is where we set the Pixel
  1042.         // CIterationsDoc* pDoc = GetDocument();
  1043.  
  1044.         if (!m_dib.SetPixel(px, py, i))
  1045.         {
  1046.             AfxMessageBox("Error writing to DIB");
  1047.             Row = RowMax;
  1048.             Col = ColMax;
  1049.             px = dim.cx;
  1050.             py = dim.cy;
  1051.             bAbort = TRUE;
  1052.             bPostFractal = FALSE;
  1053.         }
  1054.  
  1055.         if (bOrbits)
  1056.         {
  1057.             Col = px = dim.cx;
  1058.             Row = 0;
  1059.         }
  1060.  
  1061. }    
  1062.  
  1063. void CIterationsView::OnOptionsMaxzero() 
  1064. {
  1065.     b_MAX_Zero ^= 1;    
  1066.     GoDoFractal();
  1067. }
  1068.  
  1069. void CIterationsView::OnUpdateOptionsMaxzero(CCmdUI* pCmdUI) 
  1070. {
  1071.     pCmdUI->SetCheck(b_MAX_Zero);
  1072. }
  1073.  
  1074. void CIterationsView::OnFractal0prefractal() 
  1075. {
  1076.     nPreFractal = 0;
  1077.     bCombo = FALSE;
  1078.     GoDoFractal();
  1079. }
  1080.  
  1081. void CIterationsView::OnUpdateFractal0prefractal(CCmdUI* pCmdUI) 
  1082. {
  1083.     if (nPreFractal == 0)
  1084.         pCmdUI->SetCheck(TRUE);
  1085.     else
  1086.         pCmdUI->SetCheck(FALSE);
  1087. }
  1088.  
  1089. void CIterationsView::OnFractal1prefractal() 
  1090. {
  1091.     nPreFractal = 1;
  1092.     if (!bCombo)
  1093.         OnOptionsCombo();
  1094.     GoDoFractal();
  1095. }
  1096.  
  1097. void CIterationsView::OnUpdateFractal1prefractal(CCmdUI* pCmdUI) 
  1098. {
  1099.     if (nPreFractal == 1)
  1100.         pCmdUI->SetCheck(TRUE);
  1101.     else
  1102.         pCmdUI->SetCheck(FALSE);
  1103. }
  1104.  
  1105. void CIterationsView::OnFractal2prefractal() 
  1106. {
  1107.     nPreFractal = 2;
  1108.     if (!bCombo)
  1109.         OnOptionsCombo();
  1110.     GoDoFractal();
  1111. }
  1112.  
  1113. void CIterationsView::OnUpdateFractal2prefractal(CCmdUI* pCmdUI) 
  1114. {
  1115.     if (nPreFractal == 2)
  1116.         pCmdUI->SetCheck(TRUE);
  1117.     else
  1118.         pCmdUI->SetCheck(FALSE);
  1119. }
  1120.  
  1121. void CIterationsView::OnFractal3prefractal() 
  1122. {
  1123.     nPreFractal = 3;
  1124.     if (!bCombo)
  1125.         OnOptionsCombo();
  1126.     GoDoFractal();
  1127. }
  1128.  
  1129. void CIterationsView::OnUpdateFractal3prefractal(CCmdUI* pCmdUI) 
  1130. {
  1131.     if (nPreFractal == 3)
  1132.         pCmdUI->SetCheck(TRUE);
  1133.     else
  1134.         pCmdUI->SetCheck(FALSE);
  1135. }
  1136.  
  1137. void CIterationsView::OnFractal4prefractal() 
  1138. {
  1139.     nPreFractal = 4;
  1140.     if (!bCombo)
  1141.         OnOptionsCombo();
  1142.     GoDoFractal();
  1143. }
  1144.  
  1145. void CIterationsView::OnUpdateFractal4prefractal(CCmdUI* pCmdUI) 
  1146. {
  1147.     if (nPreFractal == 4)
  1148.         pCmdUI->SetCheck(TRUE);
  1149.     else
  1150.         pCmdUI->SetCheck(FALSE);
  1151. }
  1152.  
  1153. void CIterationsView::OnFractal5prefractal() 
  1154. {
  1155.     nPreFractal = 5;
  1156.     if (!bCombo)
  1157.         OnOptionsCombo();
  1158.     GoDoFractal();
  1159. }
  1160.  
  1161. void CIterationsView::OnUpdateFractal5prefractal(CCmdUI* pCmdUI) 
  1162. {
  1163.     if (nPreFractal == 5)
  1164.         pCmdUI->SetCheck(TRUE);
  1165.     else
  1166.         pCmdUI->SetCheck(FALSE);
  1167. }
  1168.  
  1169. void CIterationsView::OnFractal6prefractal() 
  1170. {
  1171.     nPreFractal = 6;
  1172.     if (!bCombo)
  1173.         OnOptionsCombo();
  1174.     GoDoFractal();
  1175. }
  1176.  
  1177. void CIterationsView::OnUpdateFractal6prefractal(CCmdUI* pCmdUI) 
  1178. {
  1179.     if (nPreFractal == 6)
  1180.         pCmdUI->SetCheck(TRUE);
  1181.     else
  1182.         pCmdUI->SetCheck(FALSE);
  1183. }
  1184.  
  1185. void CIterationsView::OnFractal7prefractal() 
  1186. {
  1187.     nPreFractal = 7;
  1188.     if (!bCombo)
  1189.         OnOptionsCombo();
  1190.     GoDoFractal();
  1191. }
  1192.  
  1193. void CIterationsView::OnUpdateFractal7prefractal(CCmdUI* pCmdUI) 
  1194. {
  1195.     if (nPreFractal == 7)
  1196.         pCmdUI->SetCheck(TRUE);
  1197.     else
  1198.         pCmdUI->SetCheck(FALSE);
  1199. }
  1200.  
  1201. void CIterationsView::OnFractal8prefractal() 
  1202. {
  1203.     nPreFractal = 8;
  1204.     if (!bCombo)
  1205.         OnOptionsCombo();
  1206.     GoDoFractal();
  1207. }
  1208.  
  1209. void CIterationsView::OnUpdateFractal8prefractal(CCmdUI* pCmdUI) 
  1210. {
  1211.     if (nPreFractal == 8)
  1212.         pCmdUI->SetCheck(TRUE);
  1213.     else
  1214.         pCmdUI->SetCheck(FALSE);
  1215. }
  1216.  
  1217. void CIterationsView::OnFractal9prefractal() 
  1218. {
  1219.     nPreFractal = 9;
  1220.     if (!bCombo)
  1221.         OnOptionsCombo();
  1222.     GoDoFractal();
  1223. }
  1224.  
  1225. void CIterationsView::OnUpdateFractal9prefractal(CCmdUI* pCmdUI) 
  1226. {
  1227.     if (nPreFractal == 9)
  1228.         pCmdUI->SetCheck(TRUE);
  1229.     else
  1230.         pCmdUI->SetCheck(FALSE);
  1231. }
  1232.  
  1233. void CIterationsView::OnFractal10prefractal() 
  1234. {
  1235.     nPreFractal = 10;
  1236.     if (!bCombo)
  1237.         OnOptionsCombo();
  1238.     GoDoFractal();
  1239. }
  1240.  
  1241. void CIterationsView::OnUpdateFractal10prefractal(CCmdUI* pCmdUI) 
  1242. {
  1243.     if (nPreFractal == 10)
  1244.         pCmdUI->SetCheck(TRUE);
  1245.     else
  1246.         pCmdUI->SetCheck(FALSE);
  1247. }
  1248.  
  1249. void CIterationsView::OnFractal11prefractal() 
  1250. {
  1251.     nPreFractal = 11;
  1252.     if (!bCombo)
  1253.         OnOptionsCombo();
  1254.     GoDoFractal();
  1255. }
  1256.  
  1257. void CIterationsView::OnUpdateFractal11prefractal(CCmdUI* pCmdUI) 
  1258. {
  1259.     if (nPreFractal == 11)
  1260.         pCmdUI->SetCheck(TRUE);
  1261.     else
  1262.         pCmdUI->SetCheck(FALSE);
  1263. }
  1264.  
  1265.  
  1266. void CIterationsView::OnFractal12prefractal() 
  1267. {
  1268.     nPreFractal = 12;
  1269.     if (!bCombo)
  1270.         OnOptionsCombo();
  1271.     GoDoFractal();
  1272. }
  1273.  
  1274. void CIterationsView::OnUpdateFractal12prefractal(CCmdUI* pCmdUI) 
  1275. {
  1276.     if (nPreFractal == 12)
  1277.         pCmdUI->SetCheck(TRUE);
  1278.     else
  1279.         pCmdUI->SetCheck(FALSE);
  1280. }
  1281.  
  1282. void CIterationsView::OnFractal13prefractal() 
  1283. {
  1284.     nPreFractal = 13;
  1285.     if (!bCombo)
  1286.         OnOptionsCombo();
  1287.     GoDoFractal();
  1288. }
  1289.  
  1290. void CIterationsView::OnUpdateFractal13prefractal(CCmdUI* pCmdUI) 
  1291. {
  1292.     if (nPreFractal == 13)
  1293.         pCmdUI->SetCheck(TRUE);
  1294.     else
  1295.         pCmdUI->SetCheck(FALSE);
  1296. }
  1297.  
  1298. void CIterationsView::OnFractal14prefractal() 
  1299. {
  1300.     nPreFractal = 14;
  1301.     if (!bCombo)
  1302.         OnOptionsCombo();
  1303.     GoDoFractal();
  1304. }
  1305.  
  1306. void CIterationsView::OnUpdateFractal14prefractal(CCmdUI* pCmdUI) 
  1307. {
  1308.     if (nPreFractal == 14)
  1309.         pCmdUI->SetCheck(TRUE);
  1310.     else
  1311.         pCmdUI->SetCheck(FALSE);
  1312. }
  1313.  
  1314. void CIterationsView::OnFractal15prefractal() 
  1315. {
  1316.     nPreFractal = 15;
  1317.     if (!bCombo)
  1318.         OnOptionsCombo();
  1319.     GoDoFractal();
  1320. }
  1321.  
  1322. void CIterationsView::OnUpdateFractal15prefractal(CCmdUI* pCmdUI) 
  1323. {
  1324.     if (nPreFractal == 15)
  1325.         pCmdUI->SetCheck(TRUE);
  1326.     else
  1327.         pCmdUI->SetCheck(FALSE);
  1328. }
  1329.  
  1330. void CIterationsView::OnFractal16prefractal() 
  1331. {
  1332.     nPreFractal = 16;
  1333.     if (!bCombo)
  1334.         OnOptionsCombo();
  1335.     GoDoFractal();
  1336. }
  1337.  
  1338. void CIterationsView::OnUpdateFractal16prefractal(CCmdUI* pCmdUI) 
  1339. {
  1340.     if (nPreFractal == 16)
  1341.         pCmdUI->SetCheck(TRUE);
  1342.     else
  1343.         pCmdUI->SetCheck(FALSE);
  1344. }
  1345.  
  1346.